package com.ruoyi.system.service.impl;

import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.system.domain.vo.EmploymentStatusVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.EmploymentInfoMapper;
import com.ruoyi.system.domain.EmploymentInfo;
import com.ruoyi.system.service.IEmploymentInfoService;

/**
 * 就业信息Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-11-05
 */
@Service
public class EmploymentInfoServiceImpl implements IEmploymentInfoService 
{
    @Autowired
    private EmploymentInfoMapper employmentInfoMapper;

    /**
     * 查询就业信息
     * 
     * @param id 就业信息主键
     * @return 就业信息
     */
    @Override
    public EmploymentInfo selectEmploymentInfoById(Long id)
    {
        return employmentInfoMapper.selectEmploymentInfoById(id);
    }

    /**
     * 查询就业信息列表
     * 
     * @param employmentInfo 就业信息
     * @return 就业信息
     */
    @Override
    public List<EmploymentInfo> selectEmploymentInfoList(EmploymentInfo employmentInfo, Long uid)
    {
        return employmentInfoMapper.selectEmploymentInfoList(employmentInfo,uid);
    }

    /**
     * 新增就业信息
     * 
     * @param employmentInfo 就业信息
     * @return 结果
     */
    @Override
    public int insertEmploymentInfo(EmploymentInfo employmentInfo)
    {
        return employmentInfoMapper.insertEmploymentInfo(employmentInfo);
    }

    /**
     * 修改就业信息
     * 
     * @param employmentInfo 就业信息
     * @return 结果
     */
    @Override
    public int updateEmploymentInfo(EmploymentInfo employmentInfo)
    {
        return employmentInfoMapper.updateEmploymentInfo(employmentInfo);
    }

    /**
     * 批量删除就业信息
     * 
     * @param ids 需要删除的就业信息主键
     * @return 结果
     */
    @Override
    public int deleteEmploymentInfoByIds(Long[] ids)
    {
        return employmentInfoMapper.deleteEmploymentInfoByIds(ids);
    }

    /**
     * 删除就业信息信息
     * 
     * @param id 就业信息主键
     * @return 结果
     */
    @Override
    public int deleteEmploymentInfoById(Long id)
    {
        return employmentInfoMapper.deleteEmploymentInfoById(id);
    }

    @Override
    public List<EmploymentStatusVO> countByEmploymentStatus() {
        return employmentInfoMapper.countByEmploymentStatus();
    }

    @Override
    public List<EmploymentStatusVO> countByEmploymentIntent() {
        return employmentInfoMapper.countByEmploymentIntent();
    }

    @Override
    public List<EmploymentStatusVO> countByEmploymentProvince() {
        return employmentInfoMapper.countByEmploymentProvince();
    }

    @Override
    public List<Map<String, Object>> getEmploymentStats() {
        List<Map<String, Object>> rawStats = employmentInfoMapper.getEmploymentStats();

        Map<String, Map<String, List<Map<String, Object>>>> groupedStats = rawStats.stream()
                .collect(Collectors.groupingBy(
                        map -> (String) map.get("grade"),
                        Collectors.groupingBy(
                                map -> (String) map.get("category"),
                                Collectors.mapping(
                                        map -> {
                                            Map<String, Object> result = new HashMap<>();
                                            result.put("name", map.get("detail"));
                                            result.put("value", map.get("count"));
                                            return result;
                                        },
                                        Collectors.toList()
                                )
                        )
                ));

        List<Map<String, Object>> formattedStats = new ArrayList<>();

        for (Map.Entry<String, Map<String, List<Map<String, Object>>>> entry : groupedStats.entrySet()) {
            Map<String, Object> gradeStats = new HashMap<>();
            gradeStats.put("name", entry.getKey());

            List<Map<String, Object>> employmentStatuses = entry.getValue().getOrDefault("employment_status", Collections.emptyList());
            List<Map<String, Object>> employmentIntents = entry.getValue().getOrDefault("employment_intent", Collections.emptyList());

            gradeStats.put("employmentStatuses", employmentStatuses);
            gradeStats.put("employmentIntents", employmentIntents);

            formattedStats.add(gradeStats);
        }

        return formattedStats;
    }

    @Override
    public List<Map<String, Object>> getProvinceStats() {
        // 从数据库中获取原始统计数据
        List<Map<String, Object>> rawStats = employmentInfoMapper.getProvinceStats();

        // 初始化一个 LinkedHashMap 用于按年级分组统计数据
        // 使用 LinkedHashMap 以保持插入顺序
        Map<String, Map<String, Object>> groupedStats = new LinkedHashMap<>();

        // 遍历原始统计数据
        for (Map<String, Object> stat : rawStats) {
            // 提取年级、省份和人数
            String grade = (String) stat.get("grade");
            String province = (String) stat.get("province");
            int count = ((Number) stat.get("count")).intValue();

            // 如果当前年级还没有对应的 Map，则初始化一个新的 HashMap
            // putIfAbsent 方法确保每个年级只初始化一次
            groupedStats.putIfAbsent(grade, new HashMap<>());

            // 获取当前年级的统计数据 Map
            Map<String, Object> gradeStats = groupedStats.get(grade);

            // 如果当前年级的统计数据 Map 中还没有 "value" 键，则初始化一个新的 ArrayList
            // 这个 ArrayList 用于存储该年级在各个省份的统计数据
            if (!gradeStats.containsKey("value")) {
                gradeStats.put("value", new ArrayList<>());
            }

            // 获取当前年级的省份统计数据列表
            List<Map<String, Object>> provinceList = (List<Map<String, Object>>) gradeStats.get("value");
            // 创建一个新的 Map 用于存储当前省份的统计数据
            Map<String, Object> provinceStat = new HashMap<>();
            provinceStat.put("name", province);
            provinceStat.put("value", count);

            // 将当前省份的统计数据添加到省份列表中
            provinceList.add(provinceStat);
        }

        // 将 groupedStats 转换为所需的格式
        List<Map<String, Object>> formattedStats = new ArrayList<>();

        // 遍历 groupedStats 中的每一个年级
        for (Map.Entry<String, Map<String, Object>> entry : groupedStats.entrySet()) {
            // 创建一个新的 Map 用于存储当前年级的统计数据
            Map<String, Object> gradeStat = new HashMap<>();

            // 设置年级名
            gradeStat.put("name", entry.getKey());
            // 将当前年级的统计数据复制到 gradeStat 中
            gradeStat.putAll(entry.getValue());
            // 将当前年级的统计数据添加到最终结果列表中
            formattedStats.add(gradeStat);
        }

        // 返回最终格式化的统计数据
        return formattedStats;
    }


}
